//// 1. 不需要参数,返回值为 2
//() -> 2
//// 2. 接收一个参数(数字类型),返回其2倍的值
//x -> 2 * x
//// 3. 接受2个参数(数字),并返回他们的和
//(x, y) -> x + y
//// 4. 接收2个int型整数,返回他们的乘积
//(int x, int y) -> x * y
//// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
//(String s) -> System.out.print(s)
//@FunctionalInterface
//interface NoParameterNoReturn {
//    //注意：只能有一个方法
//    void test();
//}
//
//
//interface NoParameterNoReturn {
//    //注意：只能有一个方法
//    void test();
//}
//
//@FunctionalInterface
//interface NoParameterNoReturn {
//    void test();
//    default void test2() {
//        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
//    }
//}



//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}



public  class T{

    public class TestDemo {
        public static void main(String[] args) {
            NoParameterNoReturn noParameterNoReturn = ()->{
                System.out.println("无参数无返回值");
            };
            noParameterNoReturn.test();
            OneParameterNoReturn oneParameterNoReturn = (int a)->{
                System.out.println("一个参数无返回值："+ a);
            };
            oneParameterNoReturn.test(10);
            MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
                System.out.println("多个参数无返回值："+a+" "+b);
            };
            moreParameterNoReturn.test(20,30);
            NoParameterReturn noParameterReturn = ()->{
                System.out.println("有返回值无参数！");
                return 40;
            };
//接收函数的返回值
            int ret = noParameterReturn.test();
            System.out.println(ret);
            OneParameterReturn oneParameterReturn = (int a)->{
                System.out.println("有返回值有一个参数！");
                return a;
            };
            ret = oneParameterReturn.test(50);
            System.out.println(ret);
            MoreParameterReturn moreParameterReturn = (int a,int b)->{
                System.out.println("有返回值多个参数！");
                return a+b;
            };
            ret = moreParameterReturn.test(60,70);
            System.out.println(ret);
        }
    }
}


//
//public static void main(String[] args) {
//    MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
//        System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
//    };
//    moreParameterNoReturn.test(20,30);
//    OneParameterNoReturn oneParameterNoReturn = a ->{
//        System.out.println("无参数一个返回值,小括号可以胜率："+ a);
//    };
//    oneParameterNoReturn.test(10);
//    NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有一行代码");
//    noParameterNoReturn.test();
////方法体中只有一条语句，且是return语句
//    NoParameterReturn noParameterReturn = ()-> 40;
//    int ret = noParameterReturn.test();
//    System.out.println(ret);
//}



@FunctionalInterface
interface NoParameterNoReturn1 {
    void test();
}

class TT{

    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn1 noParameterNoReturn1 = () -> {
         a = 99; error
            System.out.println("捕获变量：" + a);
        };
        noParameterNoReturn1.test();
    }


}



public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.forEach(new Consumer<String>(){
        @Override
        public void accept(String str){
//简单遍历集合中的元素。
            System.out.print(str+" ");
        }
    });
}



public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
//表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
    list.forEach(s -> {
        System.out.println(s);
    });
}



public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String str1, String str2) {
//注意这里比较长度
            return str1.length() - str2.length();
        }
    });
    System.out.println(list);
}


public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
//调用带有2个参数的方法，且返回长度的差值
    list.sort((str1, str2) -> str1.length() - str2.length());
    System.out.println(list);
}